Cette formation a pour but de rendre accessible Ć  tous la programmation en R. Pour cela, nous introduirons la notion de programmation dans un contexte gĆ©nĆ©ral, puis nous nous pencherons sur le langage R en partant d’une vue globale pour entrer petit Ć  petit dans les manipulations techniques.




La programmation



  • Qu’est-ce que la programmation ?

Comme nous l’informe WikipĆ©dia, la programmation - aussi appelĆ©e codage ou dĆ©veloppement, dĆ©signe l’ensemble des activitĆ©s qui permettent l’écriture de programmes informatiques. Cette Ć©criture de programmes se fait dans un langage de programmation, les 10 principaux langages sont les suivants : HTML/CSS, JavaScript, PHP, Ruby, Java, Swift, C#, C ou C++, Python, Julia et Scala. R est aussi un langage de programmation qui est, lui, davantage axĆ© sur l’analyse statistique.


  • Pourquoi la programmation ?

La troisiĆØme rĆ©volution industrielle, connue sous le nom de ā€œrĆ©volution informatiqueā€ s’accompagne d’une crĆ©ation de 2.5 trillions d’octets de donnĆ©es chaque jour. C’est dans ce contexte d’abondance des donnĆ©es qu’est nĆ©e la science des donnĆ©es, visant Ć  obtenir des informations et des connaissances Ć  partir des donnĆ©es qui gĆ©nĆØrent de la valeur. Le schĆ©ma ci-dessous peut aider Ć  comprendre comment exploiter la valeur des donnĆ©es :




Vue globale du langage R


  • Qu’est-ce que R ?

Comme dit précédemment R est un langage de programmation en libre accès créé en 1993, destiné aux statistiques et à la science des données.


  • Pourquoi R ?

Gratuit, facile d’accĆØs, puissant, reproductible, design, le langage R est Ć  la fois pertinent pour analyser les donnĆ©es, les visualiser et gĆ©nĆ©rer des rapports qui permettent - comme celui-ci, de mĆ©langer du code, du texte et des graphiques.


  • Comment coder en R ?

Pour coder en R on utilise gĆ©nĆ©ralement l’interface R studio qui permet d’interagir avec le langage R de maniĆØre aisĆ©e. Quoi qu’il en soit, l’image partagĆ©e par Sylvain montre que la programmation est un apprentissage infini :


  • Installer R sur sa machine

Pour installer l’interface RStudio il faut dans un premier temps installer R et dans un second temps tĆ©lĆ©charger l’application RStudio. Les liens de tĆ©lĆ©chargements sont disponibles sur le site rstudio.com.


  • Configurer R

Une fois l’installation terminĆ©e, il est important de configurer RStudio pour faciliter le travail sur l’interface et les partages de documents. Les paramĆØtres gĆ©nĆ©raux se trouvent dans le menu : Tools > Global Options

Vous pouvez configurer le ā€˜General’ et le ā€˜Code’ de la maniĆØre suivante :

Il est aussi important de configurer la sauvegarde des scripts ; il faut spĆ©cifier un codage ā€œUTF-8ā€ pour que les caractĆØres spĆ©ciaux de chaque script enregistrĆ© soient traitĆ©s correctement, et ainsi faciliter le partage de codes. Cette option est disponible dans la fenĆŖtre des Global Options > Code > Saving > Default text encoding > Change… > UTF-8. Enfin, dans cette mĆŖme fenĆŖtre des options gĆ©nĆ©rales de RStudio - dans l’option ā€œAppearanceā€, vous pouvez personnaliser l’apparence de votre interface en modifiant la police, la taille du texte, le thĆØme etc.

Ne pas oublier d’appliquer ces changements (ā€˜Apply’) avant de fermer la fenĆŖtre des options (ā€˜Ok’).


  • DĆ©composition d’une fenĆŖtre R

Une fenĆŖtre R Ć  son ouverture est dĆ©composĆ©e en 3 parties, 4 en diminuant la taille de la partie infĆ©rieure en cliquant sur le bouton (ou via le menu : View > Panes > Show all panes). La programmation Ć  proprement parler se fait dans la partie supĆ©rieure gauche, c’est lĆ  où on Ć©crit les scripts que l’on pourra ensuite sauvegarder.

NB : il est aussi possible de coder directement dans la console (partie inférieure gauche), la commande sera exécutée mais ne sera pas sauvegardée ; ça peut donc être intéressant pour exécuter une commande de manière instantanée (un calcul par exemple).

La partie infƩrieure droite est dƩcomposƩe en 5 onglets :

  • Files : les fichiers de l’ordinateur
  • Plots : les graphiques crƩƩs apparaĆ®tront ici
  • Packages : liste de tous les packages installĆ©s sur la machine (nous reviendrons sur la notion plus tard)
  • Help : onglet où l’on trouve toute l’aide nĆ©cessaire sur l’utilisation des fonctions
  • Viewer : les objets interactifs crƩƩs (graphiques, cartes, tableaux) apparaĆ®tront ici


  • L’environnement R

Un avantage incontournable de R est la communautĆ© qui existe autour pour trouver des ressources, de l’aide, de l’inspiration etc. On trouve notamment R-bloggers avec des nouveautĆ©s et des tutoriels Ć©crits par des utilisateurs du langage, RStudio Community pour trouver/donner de l’aide (comme un #TeamOpenData de RStudio), Stack Overflow où l’on trouve la majoritĆ© des rĆ©ponses aux questions de programmation - la plateforme n’est cependant pas propre Ć  R.

Il est aussi possible de relier RStudio Ơ Git, ce qui permet de dƩposer du code, des bases de donnƩes et des objets crƩƩs (graphiques, cartes, documents html..) sur github. Les fichiers sont ainsi centralisƩs et sauvegardƩs sur un repository qui permet de collaborer facilement sur un projet.


  • Le lexique de R

coder = programmer

ligne de commande = ligne de code

runer = exĆ©cuter une commande (bouton ā€˜Run’)

package = ensemble de fonctions

library = endroit où sont gardés les packages

working directory = rƩpertoire de travail


  • Les types de documents pour travailler avec R

Les principaux documents que l’on peut crĆ©er Ć  partir de l’interface RStudio sont les suivants :

  • R Script, extension ā€œ.Rā€ : document le plus basique où l’on peut (seulement) Ć©crire du code et l’exĆ©cuter - trĆØs fonctionnel
  • R Markdown, extension ā€œ.Rmdā€ : document où l’on peut combiner du texte, du code, des graphiques et des tableaux de maniĆØre esthĆ©tique, comme celui-ci
  • Shiny web app, extension ā€œ.Rā€ : application interactive où l’on peut assembler des visualisations et des tableaux

Pour crĆ©er un nouveau document il faut aller dans le menu : File > New File > choisir celui que vous voulez crĆ©er, ou sur le juste en dessous du ā€˜File’ dans la barre de menu.


  • Travailler avec des projets R

Ces documents peuvent ĆŖtre crƩƩs/ouverts seuls ou dans un projet : . Un Rproject est utile dĆØs lors que l’on travaille sur une analyse avec de nombreux fichiers (donnĆ©es, scripts, images…) et en collaboration avec d’autres personnes. Il est effectivement possible d’organiser son espace de travail Ć  partir de l’objet ā€˜.Rproj’ :

  • celui-ci se trouve dans un dossier où l’on centralise tous les fichiers nĆ©cessaires Ć  l’analyse
  • depuis l’emplacement où se trouve le projet on peut crĆ©er des sous-dossiers pour organiser le travail
  • en ouvrant dans RStudio le projet, les fichiers crƩƩs autour de celui-ci apparaissent dans la partie infĆ©rieure droite de la fenĆŖtre de RStudio, ils sont donc accessibles facilement comme nous le voyons ici

Organisation du travail dans le dossier de la machine

Ouverture du projet sous RStudio, accès facilité aux fichiers


  • il est alors possible d’appeler toute sorte d’objets (images, bases de donnĆ©es) en utilisant un chemin relatif et non un chemin global. Pour importer des donnĆ©es par exemple, le chemin global serait le suivant :

data <- read_csv("C:/Users/name/desktop/mon_projet/data/base.csv")

La limite de cette mĆ©thode apparaĆ®t quand on veut partager le code Ć  quelqu’un d’autre qui n’aura pas le mĆŖme chemin d’accĆØs (ne serait-ce que pour le nom d’utilisateur). En travaillant dans un projet R, les chemins d’accĆØs aux documents seront relatifs puisqu’ils dĆ©butent Ć  l’endroit où l’on travaille (working directory), c’est-Ć -dire Ć  l’emplacement du .Rproj. La commande pour importer les donnĆ©es avec le chemin relatif serait la suivante :

data <- read_csv("./data/base.csv")

Le point ā€œ.ā€ correspond au rĆ©pertoire de travail c’est-Ć -dire Ć  l’emplacement du RProject ici. Le dossier avec le projet R peut ĆŖtre dĆ©placĆ© et partagĆ©, l’import continuera de fonctionner grĆ¢ce au chemin relatif.

Pour crĆ©er un nouveau projet il faut aller dans le menu : File > New Project > New Directory > New Project > entrer un nom de projet, Ć©ventuellement changer l’espace de travail > Create Project, ou Ć  partir du juste en dessous du ā€˜Edit’ dans la barre de menu.


Bonne pratique

Un bon rĆ©flexe Ć  prendre dĆØs le dĆ©but de votre carriĆØre de programmeur est de ne laisser aucun espace blanc dans les noms des fichiers/dossiers, de maniĆØre Ć  ce qu’ils puissent ĆŖtre lus Ć  la fois par des personnes mais aussi par des machines. Les bons sĆ©parateurs des mots sont alors -ou _. Il est aussi recommandĆ© de ne pas mettre d’accent, pour prĆ©venir d’éventuels problĆØmes d’encodage.

Exemple de mauvais nom : Extraction des donnƩes de data.gouv.R

Exemple de bon nom : Extraction_donnees_data-gouv.R




Science et analyse des donnƩes avec R


Maintenant que la notion de programmation est plus claire et que vous connaissez les rouages du langage R, nous allons entrer dans le vif du sujet en apprenant Ć  manier les donnĆ©es ; que ce soit la mise en forme, l’analyse ou la visualisation. Cette partie reprendra Ć©tape par Ć©tape le schĆ©ma d’exploitation des donnĆ©es que nous avons vu en premiĆØre partie :


  • Deux maniĆØres de coder en R

Avant de nous pencher sur l’import de donnĆ©es, voyons les deux maniĆØres de coder en R : le R-base et le tidyverse. La programmation dans le langage R a Ć©tĆ© rĆ©volutionnĆ©e ces derniĆØres annĆ©es par le statisticien Hadley Wickham et son Ć©quipe, qui ont dĆ©veloppĆ© le tidyverse. Contraction de tidy et universe, le tidyverse est une collection de packages R qui ont tous la mĆŖme structure, simplifiant ainsi leur utilisation pour la data science.


Le tidyverse fonctionne grĆ¢ce au pipe (%>%) contenu dans le package magrittr, qui permet d’appliquer un certain nombre de fonctions Ć  une base de donnĆ©es. Le code est alors plus lisible grĆ¢ce Ć  une structuration des sĆ©quences d’opĆ©rations de gauche Ć  droite (et non de l’extĆ©rieur Ć  l’intĆ©rieur comme en R-base), qui permet d’ajouter des Ć©tapes n’importe où dans les sĆ©quences d’opĆ©rations.

Un exemple de code en R-base et en tidyverse :

  • R-base : h(g(f(x)))
  • tidyverse : x %>% f %>% g %>% h

Nous apprendrons Ć  coder seulement en tidyverse dont l’approche est beaucoup plus simple pour dĆ©buter la programmation.


  • Coder sous R : les bases

Pour exécuter du code il faut placer son curseur sur la ligne de commande, puis cliquer sur le bouton en haut de la fenêtre, ou appuyer sur les touches Ctrl-Enter. Pour exécuter plusieurs lignes de code simultanément il suffit de les sélectionner avant de les runer. vous pouvez notamment vous entraîner en runant de simples opérations arithmétiques :

13+4
 #> [1] 17
5*2
 #> [1] 10
13+4-5*2
 #> [1] 7

Il est possible d’assigner une valeur Ć  un objet (dataframe, liste, vecteur, fonction…) avec <- ou =, de maniĆØre Ć  les sauvegarder dans l’environnement de travail (partie en haut Ć  droite de la fenĆŖtre RStudio). Vous pouvez par exemple runer les commandes suivantes :

# OpƩrations
x <- 13+4
y <- 5*2

# Calcul du rƩsultat
resultat = x-y
resultat
 #> [1] 7

De cette maniĆØre, le code sous R se lit de droite Ć  gauche ;

  • Ć  droite on trouve la valeur
  • Ć  gauche on trouve l’objet crƩƩ


Bonne pratique

Tout texte peut ĆŖtre intĆ©grĆ© dans un script R aprĆØs un ā€œ#ā€ ; il ne sera pas considĆ©rĆ© comme du code mais comme un commentaire donc ne sera pas exĆ©cutĆ©. Un bon rĆ©flexe est de mettre le plus d’explications du code grĆ¢ce aux ā€œ#ā€, pour qu’il soit lisible et comprĆ©hensible par toute personne qui travaillerait sur le script.


  • Installation des packages fondamentaux

Comme dit prĆ©cĆ©demment, un package contient un certain nombre de fonctions qui permettent de faire toutes sortes de manipulations sur des bases de donnĆ©es ou autres. Le repository officiel où sont stockĆ©s tous les packages R est appelĆ© CRAN ; ā€œthe Comprehensive R Archive Networkā€. Pour installer un package depuis le CRAN il faut utiliser la fonction install.packages("nom_package"). Mais il existe d’autres dĆ©pĆ“ts des packages crƩƩs, tel que Git (GitHub, GitLab, Bitbucket…) ; pour installer un package stockĆ© sur github par exemple il faut utiliser la fonction install_github("user_name/package_name"), elle-mĆŖme contenue dans le package devtools.

Pour utiliser un package, aprĆØs l’avoir installĆ©, il faut l’appeler via la fonction library(nom_package). Le code ci-dessous permet d’installer les packages fondamentaux, il faut le copier, le coller dans un script R basique (File > New File > R Script) puis l’exĆ©cuter.


Plusieurs packages sont attachĆ©s au ā€œtidyverseā€ :

  • ggplot2 : pour visualiser les donnĆ©es
  • tibble : pour traiter les donnĆ©es de type ā€˜tibble’
  • tidyr : pour nettoyer les donnĆ©es
  • readr : pour importer des donnĆ©es CSV, TSV ou FWL
  • purrr : pour itĆ©rer des fonctions
  • dplyr : pour manipuler les donnĆ©e
  • stringr : pour travailler avec des chaĆ®nes de caractĆØres
  • forcats : pour travailler avec des variables catĆ©gorielles
packages <- c("tidyverse", "remotes", "devtools", "rmarkdown", "rio", "datasets")
install.packages(packages)



Importer les donnƩes


  • Deux maniĆØres d’importer des donnĆ©es en R

Il est possible d’importer des donnĆ©es dans l’environnement RStudio de deux maniĆØres : par un fichier exportĆ© prĆ©sent sur notre machine, ou directement via un lien qui pointe vers le tĆ©lĆ©chargement de ce fichier en ligne. Voici quelques exemples de plates-formes où il est possible d’en importer les donnĆ©es sans besoin prĆ©alable d’exporter le fichier :


Bonne pratique

Un autre bon rĆ©flexe est de privilĆ©gier tant que possible l’import via un lien, puisque Ƨa n’implique aucune manipulation extĆ©rieure au script, donc une plus grande reproductibilitĆ© pour partager ou automatiser le code.


  • Les diffĆ©rents types de base de donnĆ©es

Il existe un certain nombre de formats de jeux de donnƩes, nous allons lister les plus courants en prƩcisant la commande qui permet de les lire sous R et importer les donnƩes correctement.


       → Excel
library(readxl)
data <- read_excel(path = "chemin_acces/vers_le/fichier.xlsx", sheet = "feuille_n_1")  # prƩciser le nom de la feuille Ơ importer s'il y en a plusieurs


       → CSV : Comma Separated Values
library(readr)
data <- read_csv("fichier.csv") 


       → SCSV : Semicolon Separated Values
library(readr)
data <- read_delim("fichier.csv", delim = ";") 


       → TXT ou TSV : Tab Separated Values
library(readr)
data <- read_delim("fichier.txt")  # le dƩlimiteur est reconnu automatiquement par R, c'est "\t" 
# ou
data <- read_table("fichier.txt")


Il existe encore bien d’autres formats de fichiers tels que XML, JSON, SAS… Si besoin, vous trouverez toute l’aide nĆ©cessaire sur internet (notamment sur Stack Overflow vu en partie prĆ©cĆ©dente).


Astuce

Lorsque vous avez un doute sur l’utilisation d’une fonction et que vous voulez savoir quels arguments elle attend et comment les spĆ©cifier, vous pouvez placer le curseur de la souris sur le nom de la fonction Ć©crite dans le script puis appuyer sur les touches Ctrl-F1 ; la page d’aide de la fonction s’ouvrira dans la partie infĆ©rieure droite (Help) de la fenĆŖtre RStudio.


Si vous avez un doute pour importer vos donnƩes, vous pouvez le faire en presse-bouton via le menu : File > Import Dataset > From

  • From Text (base) : pour lire les fichiers .csv, .txt, .scsv, la diffĆ©rence Ć©tant dans le sĆ©parateur
  • From Text (readr) : mĆŖme fonction qu’en R-base mais ici plus rapide, avec plus d’options et la possibilitĆ© d’importer via un lien
  • From Excel : pour lire les fichiers Excel
  • From SPSS : pour lire les fichiers SPSS (Statistical Package for the Social Sciences) qui ont l’extension .sav
  • From SAS : pour lire les fichiers SAS (Statistical Analysis Software)
  • From Stata : pour lire les fichiers exportĆ©s depuis Stata, un logiciel de statistiques et d’économĆ©trie

Il est possible de ā€œjouerā€ avec les paramĆØtres si ceux par dĆ©faut ne sont pas bons ; par exemple changer le sĆ©parateur de valeurs (Delimiter), l’encoding pour reconnaĆ®tre les caractĆØres spĆ©ciaux (Locale : Configure…), le nom de la base de donnĆ©es (Name), le nombre de lignes Ć  ignorer en cas d’en-tĆŖte sur le fichier (Skip). Avant de finaliser l’import des donnĆ©es par le menu, il est important de copier le code qui apparaĆ®t en bas Ć  droite de la fenĆŖtre (Code Preview) puis le coller dans le script, pour ne pas refaire cette manipulation Ć  chaque ouverture du script, et pour le rendre reproductible.



Nettoyer les donnƩes


  • Les diffĆ©rents types de donnĆ©es

Entre une liste de notes d’élĆØves et une liste de noms de villes, on voit bien que la structure de donnĆ©es est diffĆ©rente. Listons ici les diffĆ©rents types de donnĆ©es qui existent, avant de voir comment les nettoyer :

Famille de donnƩes Structure Nom retournƩ sous R Exemple
quantitatif entier int = integer 3
dƩcimal inexact dbl = double 3.5
dƩcimal exact num = numeric 3.500001
qualitatif chaîne de caractères chr = character Ville de Paris
facteur Ć  n niveaux Factor petit / moyen / grand
facteur Ć  2 niveaux dit ā€œboolĆ©enā€ bool = boolean 0 / 1, True / False
autre date POSIX 13-12-1998


Bonne pratique

Bien que numériques, les identifiants tels que numéros de SIREN, numéros de marchés, etc. doivent être considérés comme une chaîne de caractères et non une valeur numérique.


Une fois importée, il est possible de regarder la structure des données qui composent la base grâce à la fonction str() :

# On importe des donnƩes ODS
data(iris)
# On regarde le type des variables qui composent la base
str(iris)
 #> 'data.frame':   150 obs. of  5 variables:
 #>  $ Sepal.Length: num  5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4 4.9 ...
 #>  $ Sepal.Width : num  3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
 #>  $ Petal.Length: num  1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...
 #>  $ Petal.Width : num  0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2 0.2 0.1 ...
 #>  $ Species     : Factor w/ 3 levels "setosa","versicolor",..: 1 1 1 1 1 1 1 1 1 1 ...

Nous rĆ©aliserons toutes sortes de manipulations sur une base de donnĆ©es dĆ©jĆ  chargĆ©e dans l’environnement RStudio, c’est la base iris. Cette base recense des mesures de 4 attributs de 150 fleurs appartenant Ć  3 familles diffĆ©rentes. Plus d’informations sur la base sur ce lien.


Il arrive que la structure d’une variable ne soit pas la bonne, il faut alors la changer pour avoir les donnĆ©es au bon format. Cela est possible grĆ¢ce Ć  la fonction as.type_souhaite() :

# Pour passer en chaîne de caractères la variable "Species"
iris$Species <- as.character(iris$Species)

# Pour passer en nombres dƩcimaux arrondis les 4 autres variables (sans le faire une par une)
iris[,c(1:4)] <- lapply(iris[,c(1:4)], as.double) 


Astuce

Pour accĆ©der Ć  une variable dans une base de donnĆ©es, il et possible d’utiliser le ā€œ$ā€. Il fonctionne de la maniĆØre suivante ; base_de_donnees$variable.

La fonction lapply() permet d’appliquer une fonction Ć  plusieurs variables simultanĆ©ment et permet ainsi de rĆ©duire le nombre de lignes de code dans le script.



  • Observer les donnĆ©es

VoilĆ  quelques fonctions pour observer les donnĆ©es lorsqu’elles viennent d’être importĆ©es pour les cerner au mieux :

# 5 premiĆØres lignes
head(iris, 5)
 #>   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
 #> 1          5.1         3.5          1.4         0.2  setosa
 #> 2          4.9         3.0          1.4         0.2  setosa
 #> 3          4.7         3.2          1.3         0.2  setosa
 #> 4          4.6         3.1          1.5         0.2  setosa
 #> 5          5.0         3.6          1.4         0.2  setosa

# 5 derniĆØres lignes
tail(iris, 5)
 #>     Sepal.Length Sepal.Width Petal.Length Petal.Width   Species
 #> 146          6.7         3.0          5.2         2.3 virginica
 #> 147          6.3         2.5          5.0         1.9 virginica
 #> 148          6.5         3.0          5.2         2.0 virginica
 #> 149          6.2         3.4          5.4         2.3 virginica
 #> 150          5.9         3.0          5.1         1.8 virginica

# Nombre de colonnes
ncol(iris)
 #> [1] 5

# Nombre de lignes
nrow(iris)
 #> [1] 150
length(iris)
 #> [1] 5

# Nom des colonnes
names(iris)
 #> [1] "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width"  "Species"

# Nombre de lignes ET nombre de colonnes
dim(iris)
 #> [1] 150   5

# RƩsumƩ des valeurs d'une variable
summary(iris$Petal.Length)
 #>    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
 #>   1.000   1.600   4.350   3.758   5.100   6.900

# Occurrences des valeurs d'une variable
table(iris$Species)
 #> 
 #>     setosa versicolor  virginica 
 #>         50         50         50


  • Traiter les valeurs manquantes

Il arrive souvent que certaines valeurs manquent Ć  une base de donnĆ©es, elles peuvent alors prendre plusieurs Ć©critures : NA, NaN, N/A, NC, NULL… La plus connue Ć©tant ā€œNAā€ qui signifie Not Available. La fonction is.na() peut ĆŖtre appliquĆ©e pour connaĆ®tre le nombre de valeurs manquantes dans une base de donnĆ©es, et na.omit() pour supprimer toutes les lignes qui contiennent au moins 1 valeur manquante.

# Compter le nombre de NA dans une colonne
data %>% count(is.na(nom_colonne))

# Retirer toutes les lignes avec au moins 1 NA
new_data <- na.omit(data)


  • Des donnĆ©es propres

On parle de ā€œtidy dataā€ Ć  partir du moment où les donnĆ©es sont propres, c’est-Ć -dire qu’elles respectent le schĆ©ma ci-dessous :

Chaque ligne est une observation et chaque colonne est une variable correspondant Ć  l’observation en question. Selon le format des donnĆ©es les observations peuvent correspondre Ć  des individus/pays/villes etc. (on parle de donnĆ©es en coupe, c’est-Ć -dire une ā€œphotoā€ d’une situation Ć  un moment prĆ©cis), Ć  des pĆ©riodes de temps (on parle de donnĆ©es temporelles) ou aux 2 simultanĆ©ment c’est-Ć -dire par individu et dans le temps (on parle alors de donnĆ©es de panel).



Transformer les donnƩes


  • Les principales fonctions du dplyr

Dans un premier temps nous allons voir les diffĆ©rentes fonctions qui composent le dplyr et permettent de transformer les donnĆ©es, il s’agit des fonctions suivantes :

  • filter() : pour sĆ©lectionner certaines lignes Ć  partir d’une condition
  • arrange() : pour rĆ©ordonner les lignes
  • rename() : pour changer le nom des colonnes (renommer)
  • select() : pour sĆ©lectionner certaines colonnes
  • mutate() : pour crĆ©er de nouvelles variables
  • summarise() : pour rĆ©sumer plusieurs valeurs en 1 valeur (moyenne, mĆ©diane, mode…)
  • group_by() : pour grouper les observations avant d’appliquer une fonction


       → filter()

Cette fonction sert à sélectionner des lignes dans une base de données (dataframe ; df). Les lignes qui répondent à un certain critère ou condition logique sont sélectionnées. Les filtres peuvent être appliqués tant aux variables quantitatives que qualitatives. Par exemple :

# On appelle la librairie tidyverse qui contient toutes ces fonctions et le pipe
library(tidyverse)

# Fleurs de l'espĆØce "versicolor"
df1 <- iris %>% filter(Species == "versicolor")
dim(df1)
 #> [1] 50  5

# Fleurs dont les pƩtales sont supƩrieurs ou Ʃgaux Ơ 5 cm
df2 <- iris %>% filter(Petal.Length >= 5)
dim(df2)
 #> [1] 46  5

# Fleurs de l'espèce versicolor ET dont les pétales sont supérieurs ou égaux à 5 cm
df3 <- iris %>% filter(Species == "versicolor" & Petal.Length >= 5)
dim(df3)
 #> [1] 2 5

# Fleurs dont les pƩtales sont exactement larges de 2 OU de 2.5 cm
df4 <- iris %>% filter(Petal.Width == 2 | Petal.Width == 2.5)
dim(df4)
 #> [1] 9 5

Avec le pipe () on part de la base de donnĆ©es entiĆØre puis on applique nos filtres. On obtient ici deux sous-dataframes, et grĆ¢ce Ć  la fonction dim() on voit que l’on a :

  • 50 fleurs de l’espĆØce versicolor
  • 46 fleurs dont les pĆ©tales sont Ć©gaux ou plus longs que 5 cm
  • 2 fleurs de l’espĆØce versicolor dont les pĆ©tales sont longs d’au moins 5 cm
  • 9 fleurs dont les pĆ©tales sont larges d’exactement 2 ou 2.5 cm


Le tableau ci-dessous rĆ©sume les filtres que l’on peut appliquer sur une plusieurs variable(s) d’une base de donnĆ©es. Pour filtrer des variables qualitatives il faut mettre la condition entre guillemets pour que la machine reconnaisse qu’il s’agit d’un texte.

Equation Traduction pour R Exemple
Ć©gal == Species == ā€œversicolorā€
diffĆ©rent != Species != ā€œsetosaā€
supƩrieur > Petal.Length > 5
supƩrieur ou Ʃgal >= Petal.Length >= 5
infƩrieur < Petal.Length < 5
infƩrieur ou Ʃgal <= Petal.Length <= 5


       → arrange()

Cette fonction sert Ơ rƩordonner les observations selon un ordre alphabƩtique ou numƩrique croissant ou dƩcroissant. Quelques exemples ci-dessous :

# On trie par longueur de sƩpale ascendante
iris <- iris %>% arrange(Sepal.Length)

# On trie par longueur de pƩtale descendante
iris <- iris %>% arrange(desc(Petal.Length))

# On trie par espèce puis par largeur de pétale ascendante
iris <- iris %>% arrange(Species, Petal.Width)


Bonne pratique

Ici nous avons attribuĆ© les changements sur la mĆŖme base de donnĆ©es ā€œirisā€, ce qui a ā€œĆ©crasĆ©ā€ l’ancienne par la nouvelle dans laquelle les observations sont triĆ©es d’une certaine maniĆØre. Lorsque vous ĆŖtes sĆ»rs de vos modifications vous pouvez attribuer les modifications au mĆŖme nom d’objet ce qui Ć©crasera l’ancien, mais dĆØs lors que vous voulez garder une trace de la base initiale il convient de crĆ©er un nouvel objet, c’est-Ć -dire avec un nouveau nom qui apparaĆ®tra dans votre environnement de travail (partie supĆ©rieure droite de la fenĆŖtre RStudio).


       → rename()

Cette fonction permet de renommer une ou plusieurs colonnes d’un dataframe, elle fonctionne de la maniĆØre suivante : data <- data %>% rename(nouveau_nom = ancien_nom). Ci-dessous un exemple :

# On renomme 2 colonnnes
iris <- iris %>% rename(espece = Species,
                        longueur_petale = Petal.Length)

# Noms de colonnes en majuscules
names(iris) <- names(iris) %>% toupper

# Noms de colonnes en minuscules
names(iris) <- names(iris) %>% tolower


       → select()

Cette fonction permet de sƩlectionner certaines colonnes, cela est possible en les identifiant par leur nom ou leur place dans le dataframe (numƩro de colonne). Quelques exemples :

# Sous df (dataframe) avec 2 colonnes
df5 <- iris %>% select(espece, sepal.width)
  # ou
df5_bis <- iris %>% select(5, 2)

# Sous df sans 1 colonne
df6 <- iris %>% select(-longueur_petale)
  # ou
df6_bis <- iris %>% select(-3)

# Sous df sans 2 colonnes
df6 <- iris %>% select(-c(longueur_petale,petal.width)) # c() permet de mettre dans 1 objet plusieurs arguments sƩparƩs par des virgules
  # ou
df6_bis <- iris %>% select(-c(3,4))

# On change l'ordre des colonnes
iris <- iris %>% select(5,2:4,1)


Astuce

Lorsqu’un nom de colonne contient un espace (par exemple : taille individu) il faut l’entourer de ` pour qu’il soit reconnu comme le nom d’une seule colonne par R. Sans cette astuce, la commande ne pourra pas s’exĆ©cuter, d’où l’importance de nommer les bases de donnĆ©es et leurs variables par des noms sĆ©parĆ©s par les caractĆØres - ou _.

Exemple de mauvaise commande : data$premier nom <- as.numeric(data$premier nom)

Exemple de bonne commande : data$`premier nom` <- as.numeric(data$`premier nom`)


        → mutate()

Cette fonction permet de crĆ©er de nouvelles variables Ć  partir des variables existantes, elle est trĆØs utile pour l’analyse de donnĆ©es. Elle fonctionne de la maniĆØre suivante :

data <- data %>% mutate(nouvelle_colonne = ancienne_colonne*100)


La ā€œmutationā€ peut ĆŖtre arithmĆ©tique comme textuelle.

# On crƩƩ 1 colonne et on modifie 1 autre
iris <- iris %>% mutate(pourcentage_max_petale_width = petal.width / max(petal.width) *100,
                        espece = paste("L'espĆØce est", espece, sep = ": "))

# On affiche les 5 premières lignes des variables crées
head(iris[,c(1,6)], 5)
 #>                 espece pourcentage_max_petale_width
 #> 1 L'espĆØce est: setosa                            4
 #> 2 L'espĆØce est: setosa                            4
 #> 3 L'espĆØce est: setosa                            4
 #> 4 L'espĆØce est: setosa                            4
 #> 5 L'espĆØce est: setosa                            4

La commande ci-dessus a par exemple permis de crƩer une variable qui informe Ơ combien de points de pourcentage la largeur du pƩtale se situe par rapport Ơ la largeur maximale.

En deuxiĆØme argument de la fonction mutate() on modifie la variable espece (on Ć©crase l’ancienne variable) en ajoutant du texte grĆ¢ce Ć  la fonction paste(). Cette derniĆØre permet de coller du texte, ici avant chaque espĆØce de fleur on ajoute ā€œL’espĆØce est:ā€, puis on colle le nom actuel de l’espĆØce qui se trouve dans la base (sep correspondant au sĆ©parateur entre le texte ajoutĆ© et l’ancienne valeur).


       → summarise()

Cette fonction permet de résumer plusieurs valeurs en une seule, ce qui est très utile pour avoir quelques statistiques sur les bases de données.

# Calcul de la longueur moyenne des pƩtales
iris %>% summarise(moyenne_PL = mean(longueur_petale))
 #>   moyenne_PL
 #> 1      3.758

# Calcul de la largeur maximale des sƩpales
iris %>% summarise(max(sepal.width))
 #>   max(sepal.width)
 #> 1              4.4

# Calcul des minimums des mesures des pƩtales
iris %>% summarise(min(petal.width),
                   min(longueur_petale))
 #>   min(petal.width) min(longueur_petale)
 #> 1              0.1                    1


On peut aussi calculer des statistiques sur toutes les variables Ć  la fois avec la fonction summarise_all() :

# Calcul des mƩdianes de toutes les variables
iris %>% summarise_all(median)
 #>   espece sepal.width longueur_petale petal.width sepal.length
 #> 1     NA           3            4.35         1.3          5.8
 #>   pourcentage_max_petale_width
 #> 1                           52

# Calcul des Ʃcart-types et de la variance 
iris %>% select(-espece) %>% summarise_all(list(sd, var))  #list() quand plusieurs mesures Ć  la fois
 #>   sepal.width_fn1 longueur_petale_fn1 petal.width_fn1 sepal.length_fn1
 #> 1       0.4358663            1.765298       0.7622377        0.8280661
 #>   pourcentage_max_petale_width_fn1 sepal.width_fn2 longueur_petale_fn2
 #> 1                         30.48951       0.1899794            3.116278
 #>   petal.width_fn2 sepal.length_fn2 pourcentage_max_petale_width_fn2
 #> 1       0.5810063        0.6856935                           929.61

On voit que la mĆ©diane n’a pas Ć©tĆ© calculĆ©e pour la variable ā€˜espece’ puisqu’elle n’est pas numĆ©rique, la valeur retournĆ©e est donc NA (Not Available). Pour la deuxiĆØme commande qui calcule l’écart-type et la variance, on exclut donc cette variable qualitative grĆ¢ce Ć  la fonction select() que nous avons vu prĆ©cĆ©demment.


Le tableau ci-dessous rĆ©sume les diffĆ©rentes statistiques que l’on peut calculer sur les donnĆ©es, avec la fonction Ć©quivalente sous R :
OpƩration Commande R Exemple
moyenne mean mean(Petal.Length)
mƩdiane med med(Petal.Length)
Ʃtendue range range(Petal.Length)
minimum min min(Petal.Length)
maximum max max(Petal.Length)
Ʃcart-type sd sd(Petal.Length)
variance var var(Petal.Length)
skewness skewness skewness(Petal.Length)
kurtosis kurtosis kurtosis(Petal.Length)
quantiles quantile quantile(Petal.Length, probs = seq(0, 1, 1/10)

Le dernier argument des sĆ©quences de probabilitĆ©s pour les quantiles prĆ©cise le type de quantiles que l’on souhaite calculer :

  • quantile(Petal.Length, probs = seq(0, 1, 1/4) : pour obtenir les quartiles
  • quantile(Petal.Length, probs = seq(0, 1, 1/10) : pour obtenir les dĆ©ciles
  • quantile(Petal.Length, probs = seq(0, 1, 1/100) : pour obtenir les centiles etc.


       → group_by()

Cette derniĆØre fonction principale du tidyverse permet de grouper les variables, elle est spĆ©cialement utile en analyse de donnĆ©es pour calculer des statistiques par groupe (genre, pays, espĆØce…). group_by() prend le dataframe et le converti en une base groupĆ©e pour laquelle les opĆ©rations seront effectuĆ©es non plus sur la base entiĆØre mais pour chacun des groupes identifiĆ©s.

# Nombre d'observations par groupe
iris %>% group_by(espece) %>% summarise(n())
 #> # A tibble: 3 x 2
 #>   espece                   `n()`
 #>   <chr>                    <int>
 #> 1 L'espĆØce est: setosa        50
 #> 2 L'espĆØce est: versicolor    50
 #> 3 L'espĆØce est: virginica     50

# Calcul de la taille moyenne des pétales par espèce
iris %>% group_by(espece) %>% summarise(mean(longueur_petale))
 #> # A tibble: 3 x 2
 #>   espece                   `mean(longueur_petale)`
 #>   <chr>                                      <dbl>
 #> 1 L'espĆØce est: setosa                        1.46
 #> 2 L'espĆØce est: versicolor                    4.26
 #> 3 L'espĆØce est: virginica                     5.55

On voit par exemple que l’on a 50 fleurs par espĆØce dans notre base, et qu’en moyenne l’espĆØce virginica a les plus longs pĆ©tales : 5.55cm.



  • Les combinaisons de donnĆ©es

Nous savons à présent comment traiter les données grâce aux principales fonctions du dplyr, mais une manipulation importante reste à apprendre ; les combinaisons de données. Il y a 4 types de fonctions dans le dplyr qui permettent la combinaison de données :

  • les jointures lorsque les df ont des observations ou variables diffĆ©rentes mais 1 colonne commune
  • les filtres sur les observations d’un df basĆ©s sur les observations d’un autre df
  • les liaisons lorsque les 2 dataframes (df) ont exactement les mĆŖmes observations ou variables
  • les opĆ©rations pour combiner les observations des 2 df

Toutes ces fonctions ont la même structure : les deux premiers arguments sont des dataframes, et le résultat sera une nouvelle base du même type que le df stipulé comme premier argument.


Pour illustrer les fonctions de jointures et les filtres nous les appliquerons aux 2 bases de donnƩes suivantes, reprises de la cheatsheet Data Wrangling :


       → Jointures

Il y a 4 types de jointures applicables dĆØs lors qu’une variable (colonne) est commune aux 2 df : cela peut ĆŖtre utile par exemple pour ajouter des informations d’une base extĆ©rieure (bases nationales telles que Sirene, PrĆ©noms, DECP…) Ć  une base existante.

Il est nĆ©cessaire d’avoir une variable de jointure, dite ā€œclĆ©ā€ (identifiants, numĆ©ros de SIRET, noms de pays…) qui permettra d’unir les 2 bases, elle se spĆ©cifie dans l’argument ā€˜by=’. Ici, la clĆ© est x1 qui est prĆ©sente dans a comme dans b.


left_join(a, b, by = "x1") : ajoute les lignes communes de b Ơ a. Cette fonction est la plus utilisƩe pour ajouter des informations extƩrieures Ơ une base de donnƩes existante.



right_join(a, b, by = "x1") : ajoute les lignes communes de a Ć  b



inner_join(a, b, by = "x1") : joint en ne gardant que les lignes communes aux 2 df



full_join(a, b, by = "x1") : joint les donnƩes en gardant toutes les valeurs


Astuce

Lorsque la variable de jointure (la clĆ©) n’a pas le mĆŖme nom dans les 2 bases Ć  joindre, il est possible de spĆ©cifier les noms Ć  matcher. La commande est alors la suivante, ā€œcol_1ā€ correspondant au nom de colonne dans le df1, et ā€œCol_n1ā€ dans le df2 :

new_df <- left_join(df1, df2, by = c("col_1" = "Col_n1"))


       → Filtres


semi_join(a, b, by = "x1") : toutes les lignes dans a qui matchent celles dans b



anti_join(a, b, by = "x1") : toutes les lignes dans a qui ne matchent pas celles dans b



Pour illustrer les fonctions d’opĆ©rations et de liaisons nous les appliquerons aux 2 bases de donnĆ©es suivantes :


       → OpĆ©rations


intersect(y, z) : lignes qui apparaissent dans y ET dans z



union(y, z) : lignes qui apparaissent dans y ET/OU dans z



setdiff(y, z) : lignes qui apparaissent dans y MAIS PAS dans z


       → Liaisons


bind_rows(y, z) : ajoute z Ć  y en tant que nouvelles lignes



bind_cols(y, z) : ajoute z Ć  y en tant que nouvelles colonnes


Bonne pratique

Les fonctions bind_rows() (ou rbind) et bind_cols() (ou cbind) font de simples liaisons entre 2 jeux de donnĆ©es, sans match prĆ©alable sur les valeurs communes. Elles ne peuvent donc ĆŖtre appliquĆ©es qu’aux bases de donnĆ©es qui ont exactement les mĆŖmes spĆ©cifications :

  • les mĆŖmes colonnes et dans le mĆŖme ordre pour appliquer la fonction bind_rows()
  • les mĆŖmes lignes et dans le mĆŖme ordre pour appliquer la fonction bind_cols()



Visualiser les donnƩes


La partie de visualisation qui vient aprĆØs l’import, le nettoyage et le traitement est trĆØs importante dans la science et l’analyse de donnĆ©es. Le mot-clĆ©, un plutĆ“t le package clĆ© pour faire des graphiques sous R est ggplot. Initialement dĆ©veloppĆ© par Hadley Wickham, ce package permet de crĆ©er facilement des graphiques de qualitĆ© avec une immense variĆ©tĆ© de paramĆØtres modifiables selon les besoins, ce qui permet de crĆ©er des graphiques adaptĆ©s Ć  tous types de problĆØmes.

Quelque soit le graphique voulu, il y a toujours 3 ƩlƩments qui composent la fonction ggplot() :

  • les donnĆ©es qui vont ĆŖtre visualisĆ©es : data=
  • les propriĆ©tĆ©s esthĆ©tiques (aesthetics : aes(x,y)) pour indiquer les variables X (abscisses=axe horizontal) et Y (ordonnĆ©es=axe vertical), contrĆ“ler la couleur, la taille ou la forme du dernier composant
  • la gĆ©omĆ©trie qui sera reprĆ©sentĆ©e, celle-ci dĆ©finit le type de graphique (histogramme, boxplot, lignes, densitĆ©, nuages de points…) : geom_**()


Le tableau ci-dessous reprend tous les types de gƩomƩtrie faisables Ơ partir de la fonction ggplot :

GƩomƩtrie Commande R Exemple
Nuage de points geom_point
Ligne geom_line
BoƮte Ơ moustaches geom_boxplot
Violon geom_violin
DensitƩ geom_density
Histogramme geom_histogram
Barres geom_bar


Nous allons maintenant construire un graphique pas-Ć -pas en introduisant tous les paramĆØtres modifiables Ć  partir du package ggplot.


La structure de la fonction ggplot est la suivante, avec les 3 principaux ƩlƩments dƩcrits ci-dessus :

# ModĆØle d'une fonction ggplot
ggplot(data = <DATA>) + 
  <GEOM_FUNCTION>(mapping = aes(<MAPPINGS>))


Sur nos données de fleurs (iris) nous construisons un premier graphique en nuage de points où nous introduirons peu à peu différents paramètres.

# On recharge les donnƩes iris pour ne pas avoir les modifications des parties prƩcƩdentes
data(iris)

# Graphique en nuage de points
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length))

Sur ce graphique le plus basique :

  • les donnĆ©es sont appelĆ©es dans la fonction ggplot
  • le type de gĆ©omĆ©trie est spĆ©cifiĆ© dans la fonction geom_** qui est ajoutĆ©e par un + (ici geom_point puisque nous voulons un nuage de points)
  • les variables Ć  visualiser sont prĆ©cisĆ©es comme arguments x et y du mapping.

Nous pouvons personnaliser les points en spécifiant certains paramètres tels que :

  • color ou colour : la couleur des points
  • size : la taille des points (par dĆ©faut Ć  1)
  • alpha : l’opacitĆ© des points (0 < alpha < 1, où 1 correspond Ć  une opacitĆ© totale)
  • shape : la forme des points

Astuce

Pour tous ces paramĆØtres, un argument normal peut ĆŖtre spĆ©cifie (ā€˜red’ pour la couleur, 2 pour la taille etc.), mais il est aussi possible de mettre le nom d’une autre variable de maniĆØre Ć  intĆ©grer une information supplĆ©mentaire au graphique. Ce peut ĆŖtre une variable catĆ©gorielle pour la couleur, une variable numĆ©rique pour la taille des points etc.


  • Personnalisation basique
# Graphique en nuage de points personnalisƩ
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length), 
             color = "blue", size = 2, alpha = 0.7, shape = 2)

Il existe sur R deux maniĆØres de renseigner les couleurs : soit en spĆ©cifiant la couleur par son nom (exemple : ā€œbrownā€), soit en la spĆ©cifiant par son code Hex (exemple : ā€œ#dd9933ā€). Il s’agit d’une chaĆ®ne de 6 caractĆØres (chiffres et/ou lettres) qui correspond Ć  une couleur que l’on peut crĆ©er soi-mĆŖme, sur le tableau ci-dessous on retrouve une palette de couleurs dĆ©jĆ  crƩƩes pour lesquelles on a le code HEX.

Les formes des points peuvent aussi ĆŖtre spĆ©cifiĆ©es de deux maniĆØres : soit par un chiffre (exemple : 18) qui correspond Ć  une forme dĆ©jĆ  dĆ©finie visible dans le tableau ci-dessous, soit par un caractĆØre - un seul (exemple : ā€œBā€), qui sera utilisĆ© comme forme de point.

Les couleurs Les formes
pour plus d’informations pour plus d’informations


  • Personnalisation en fonction d’autres variables
# Forme et couleur selon l'espĆØce de fleur
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species))

# Taille et opacitƩ selon la largeur du pƩtale
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, alpha = Petal.Width, size = Petal.Width))

Sur les graphiques ci-dessus on a dĆ©fini les paramĆØtres visuels des points selon d’autres variables du dataframe ā€˜iris’. Comme il s’agit de variables, leur spĆ©cification se fait Ć  l’intĆ©rieur de la parenthĆØse aes() qui pour rappel, correspond aux propriĆ©tĆ©s esthĆ©tiques.


  • Les titres

Par dĆ©faut le nom des variables sera mis comme label aux axes des abscisse et des ordonnĆ©es, mais il est possible de les modifier ou d’ajouter des titres au graphique grĆ¢ce Ć  la fonction labs(), qui peut ĆŖtre ajoutĆ©e aux paramĆØtres actuels par un +.

# Titres du graphique
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  labs(title = "Relation entre les longueurs des sƩpales et des pƩtales", 
       subtitle = "Différenciée par espèce de fleur",
       caption = "DonnƩes de la base Iris", 
       x = "Longueur du sƩpale", 
       y = "Longueur du pƩtale") 


Pour n’avoir aucun titre sur le graphique il suffit de spĆ©cifier x et y = NULL dans la fonction labs() :

# Aucun titre
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  labs(x = NULL, 
       y = NULL) 


  • Les thĆØmes

Il est possible de modifier l’apparence du graphique (taille, polices et couleur des titres, fond du graphique, quadrillages etc.) de deux maniĆØres :

  • manuellement en spĆ©cifiant les Ć©lĆ©ments Ć  modifier dans la fonction theme() qui peut s’ajouter Ć  la suite des paramĆØtres existant du graphique par un +
  • automatiquement en utilisant des thĆØmes dĆ©jĆ  dĆ©finis dans ggplot grĆ¢ce Ć  la fonction theme_**()

La liste complète des thèmes disponibles se trouve au lien ggplot2.tidyverse.org, voilà quelques exemples de thèmes appliqués à notre graphique en construction :

# ThĆØmes
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  theme_minimal()

ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  theme_classic()

ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  theme_light()

ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  theme_dark()

D’autres encore sont disponibles dans le package ggthemes, l’utilisation est la mĆŖme que pour les thĆØmes de ggplot2, aprĆØs avoir installĆ© le package (install.package(ā€œggthemesā€)). La liste des thĆØmes disponibles dans ce package se trouve ici.


  • La lĆ©gende

Les éléments de légende peuvent être modifiés comme arguments de la fonction theme() que nous venons de voir, il est possible de modifier la position, le titre, les textes, les couleurs de la légende. Quelques exemples :

# Position 
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  theme(legend.position = "top")  #top, bottom, left or right

# ParamƩtrage du titre de la lƩgende
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  theme(legend.title = element_text(color="blue", size=10, 
                                      face="bold"))
# ParamƩtrage du texte de la lƩgende
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  theme(legend.text = element_text(colour="red", size=10, 
                                     face="italic"))

# Supprimer la lƩgende
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  theme(legend.position = "none")

Astuce

Bien que l’apparence puisse ĆŖtre dĆ©finie par la fonction theme_**(), il est possible de modifier les paramĆØtres du thĆØme existant en ajoutant aprĆØs celle-ci la fonction theme() - dans laquelle il est par exemple possible de modifier les Ć©lĆ©ments de la lĆ©gende, comme ci-dessus.


  • Les facettes

Lorsque l’on veut reprĆ©senter graphiquement les donnĆ©es par groupe on peut le faire de diffĆ©rentes maniĆØres :

  • en les colorant selon le groupe (comme vu prĆ©cĆ©demment avec l’espĆØce de fleur)
  • en les sĆ©parant en sous-graphiques selon le groupe

Dans le package ggplot ce sont les fonctions facet_grid() et facet_wrap() qui permettent de crĆ©er des ā€˜facettes’ Ć  un graphique, selon une variable catĆ©gorielle (un groupe).


# Facettes sur une seule ligne avec facet_grid 
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  facet_grid(cols = vars(Species)) 

# Facettes sur une seule colonne avec facet_grid 
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  facet_grid(rows = vars(Species)) 

# Facettes en matrice avec facet_wrap
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  facet_wrap(vars(Species), ncol = 2, nrow = 2) 


  • Les limites

La fonction lims() permet de spécifier soi-même les limites du graphique, de la manière suivante : c(min, max).

# Modification des limites
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  lims(x = c(1,10), y = c(2,7))


  • Les diffĆ©rentes gĆ©omĆ©tries

Avec le package ggplot il est facile de combiner plusieurs géométries sur un même graphique. Sur les visualisations qui suivent, nous avons ajouté une ligne qui relie tous les points grâce à la fonction geom_line(), puis une ligne qui représente la tendance générale (courbe lissée) grâce à la fonction geom_smooth().

# Geom_point + geom_line
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  geom_line(mapping = aes(x = Sepal.Length, y = Petal.Length))

# Geom_point + geom_smooth
ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
  geom_smooth(mapping = aes(x = Sepal.Length, y = Petal.Length))  #ou stat_smooth()



Ā Ā Ā Ā Ā Ā Voyons aussi quelques exemples d’autres types de graphiques que le nuage de points sur lequel nous travaillons depuis le dĆ©but de cette partie.


Le boxplot aussi appelĆ© la boĆ®te Ć  moustaches permet de visualiser une distribution, de la mĆŖme maniĆØre qu’un histogramme, violin plot ou graphique en densitĆ© le permettent. Sur le graphique de droite nous ajoutons la moyenne de chaque longueur de sĆ©pale par espĆØce, grĆ¢ce Ć  la fonction stat_summary(). Celle-ci permet d’intĆ©grer aux graphiques des statistiques, sans besoin de les calculer avant le graphique. L’argument fun permet de prĆ©ciser le type de statistique souhaitĆ© ; ici fun = mean pour reprĆ©senter par un point la moyenne de la variable ā€˜Sepal.Length’.

# Box plot
ggplot(data = iris) + 
  geom_boxplot(mapping = aes(x = Species, y = Sepal.Length))

# Box plot avec valeur moyenne pour chaque espĆØce
ggplot(data = iris) + 
  geom_boxplot(mapping = aes(x = Species, y = Sepal.Length)) +
  stat_summary(mapping = aes(x = Species, y = Sepal.Length), fun = mean, color = 'red')


Les histogrammes permettent aussi d’observer la distribution d’une variable, ils montrent le nombre d’observations par valeur. Ici par exemple, 4 fleurs ont un sĆ©pale de moins de 4.5 cm et 1 fleur a un sĆ©pale de 4.5 cm. Sur le deuxiĆØme graphique on distingue par espĆØce, ce qui permet d’observer des sĆ©pales plus longs pour l’espĆØce ā€˜virginica’ et plus courts pour l’espĆØce ā€˜setosa’.

# Histogramme
ggplot(data = iris) + 
  geom_histogram(mapping = aes(x = Sepal.Length))  

# Histogramme colorƩ par groupe
ggplot(data = iris) + 
  geom_histogram(mapping = aes(Sepal.Length, fill = Species),  #fill contrƓle la couleur de remplissage
                 color = 'black')  #color contrƓle la couleur des bordures


Les graphiques en barres permettent de reprĆ©senter un montant, une rĆ©partition par variable catĆ©gorielle (groupes). Ici on regarde le nombre d’observations (fleurs) de la base dans chaque espĆØce. Il y en a 50 par espĆØce don la reprĆ©sentation n’est pas trĆØs pertinente, mais on voit en deuxiĆØme graphique la mĆŖme visualisation avec les barres horizontales, ce qui est possible grĆ¢ce Ć  la fonction coord_flip() que l’on ajoute Ć  la suite du code existant.

# Bar plot
ggplot(data = iris) + 
  geom_bar(mapping = aes(x = Species))  

# Bar plot horizontale
ggplot(data = iris) + 
  geom_bar(mapping = aes(x = Species)) +
  coord_flip()


Il existe encore bien d’autres gĆ©omĆ©tries dans le package ggplot qui permettent de reprĆ©senter toutes sortes de variables. Les liens suivants aident Ć  utiliser la bonne visualisation selon ce que l’on cherche Ć  reprĆ©senter et/ou selon le type de variable :

https://clauswilke.com/dataviz/directory-of-visualizations.html

https://rkabacoff.github.io/datavis/


  • Les combinaisons de graphiques

Lorsque l’on cherche Ć  combiner plusieurs graphiques sur une mĆŖme page on peut utiliser la fonction grid.arrange() contenue dans le package gridExtra (install.packages("gridExtra") pour l’installer). Pour l’utiliser il faut au prĆ©alable sauvegarder les graphiques crƩƩs dans un objet, de maniĆØre Ć  les appeler dans la fonction grid.arrange(). Dans un premier temps on combine 2 graphiques cĆ“te Ć  cĆ“te sur une mĆŖme ligne donc sur 2 ā€œcolonnesā€ (nrow = 1, et ncol = 2) :

# Box plot avec valeur moyenne pour chaque espĆØce
g1 <- ggplot(data = iris) + 
  geom_boxplot(mapping = aes(x = Species, y = Sepal.Length)) +
  stat_summary(mapping = aes(x = Species, y = Sepal.Length), fun = mean, color = 'red')

# Histogramme colorƩ par groupe
g2 <- ggplot(data = iris) + 
  geom_histogram(mapping = aes(Sepal.Length, fill = Species), 
                 color = 'black') 

# Combinaison des graphiques
library(gridExtra)
grid.arrange(g1, g2, ncol = 2, nrow = 1)


Puis on les combine sur une mĆŖme colonne donc sur 2 lignes (nrow = 2, et ncol = 1) :

# Box plot avec valeur moyenne pour chaque espĆØce
g1 <- ggplot(data = iris) + 
  geom_boxplot(mapping = aes(x = Species, y = Sepal.Length)) +
  stat_summary(mapping = aes(x = Species, y = Sepal.Length), fun = mean, color = 'red')

# Histogramme colorƩ par groupe
g2 <- ggplot(data = iris) + 
  geom_histogram(mapping = aes(Sepal.Length, fill = Species), 
                 color = 'black') 

# Combinaison des graphiques
grid.arrange(g1, g2, ncol = 1, nrow = 2)


  • Les graphiques dynamiques

Tous les graphiques que nous venons de voir jusqu’ici Ć©taient statiques, mais il est possible de les rendre dynamiques grĆ¢ce Ć  la fonction ggplotly() contenue dans le package plotly (install.packages("plotly") pour l’installer). Il suffit de sauvegarder le graphique crƩƩ dans un objet puis de passer cet objet dans la fonction ggplotly() :

# Histogramme colorƩ par groupe
g1 <- ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) 

# Graphique dynamique
library(plotly)
ggplotly(g1)

Il est maintenant possible de zoomer sur le graphique, de capturer une image, de passer le curseur sur les diffĆ©rentes valeurs etc. On peut voir que lorsque l’on passe le curseur sur les points, les valeurs des variables entrĆ©es dans la fonction apparaissent ; on a ici ā€˜Sepal.Length’, ā€˜Species’ et ā€˜Petal.Length’. Mais il est possible de customiser ce texte pour le rendre plus lisible, ce qui se fait directement dans le graphique ggplot puis est appelĆ© dans la fonction ggplotly().

# Histogramme colorƩ par groupe
g1 <- ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species,
                           text = paste("Fleur au pƩtale de", Petal.Length, "cm, et sƩpale de", Sepal.Length, "cm",
                                        "\n", "EspĆØce", Species)))  #"\n" permet d'aller Ć  la ligne

# Graphique dynamique
ggplotly(g1, tooltip = c("text"))

Comme on le voit dans la commande, il faut utiliser la fonction paste() qui permet de coller du texte (entre guillemets) et la valeur des variables en sĆ©parant le tout par des virgules. Ce texte est Ć  rentrer dans les paramĆØtres esthĆ©tiques (aes()), puis Ć  appeler dans la fonction ggplotly() par l’argument tooltip = c("text").


  • Sauvegarde de graphiques

Une fois les graphiques crƩƩs, il est possible de les exporter via la fonction ggsave() contenue dans le package ggplot. Le premier argument correspond au nom tel que sera exportĆ© le graphique, le second (plot) correspond Ć  l’objet crƩƩ sous R que l’on veut exporter, puis en 3ĆØ et 4ĆØ arguments peuvent ĆŖtre spĆ©cifiĆ©es les largeurs et hauteurs souhaitĆ©es pour le graphique. Il s’enregistrera dans le working directory actuel.

ggsave("mon_graphique.png", plot = g1, width = 8, height = 6)


Nous avons vu dans cette partie quelques bases pour construire un graphique sous R, mais beaucoup d’autres choses encore peuvent ĆŖtre ajoutĆ©es, modifiĆ©es etc. Vous pouvez trouver des modĆØles de graphique dĆ©jĆ  construits sous R avec leur code sur R Graph Gallery, il ne reste plus qu’à les modifier pour les appliquer Ć  nos donnĆ©es.


Astuce

De la mĆŖme maniĆØre qu’il est possible d’importer des donnĆ©es en presse-boutons, il est aussi possible de construire des graphiques en presse-boutons rĆ©cupĆ©rer le code, et l’intĆ©grer au script existant. Cela est faisable avec la fonction esquisser() contenue dans le package esquisse (install.packages("esquisse") pour l’installer). Pour l’utiliser il suffit d’exĆ©cuter la commande suivante qui va ouvrir une fenĆŖtre permettant de construire un graphique pas-Ć -pas : esquisse::esquisser().



Communiquer


Enfin, la derniĆØre partie du schĆ©ma de traitement des donnĆ©es correspond Ć  la communication des rĆ©sultats. Nous ne verrons que les rapports R Markdown (Rmd) dans cette partie, qui permettent de combiner du texte, du code, des graphiques, des images et des tableaux avec une mise en page propre et totalement personnalisable. Un document Rmd se crĆ©e via le menu : File > New File > R Markdown. Il est alors possible de prĆ©ciser un nom d’auteur et un titre au rapport, ainsi que le type de document qui sera gĆ©nĆ©rĆ©. 3 types existent : un document html (comme celui-ci), un document PDF ou encore un document Word. Selon l’usage le type de document choisi sera diffĆ©rent.

Astuce

Bien qu’il faille choisir le type de document dĆØs la crĆ©ation du document Rmd, il est possible ensuite de changer le document alors qu’il est en cours d’écriture, ce qui permet de switcher facilement d’un format Ć  un autre.


Tandis que les documents PDF et Word vont ĆŖtre sĆ©parĆ©s en pages et seront statiques, les documents html vont eux permettre d’intĆ©grer des tables ou des graphiques interactifs, des cartographies, des onglets et bien d’autres choses encore.

Après avoir créé un document R Markdown, vous pouvez générer le rapport en cliquant sur le bouton knit qui se trouve à droite du bouton de sauvegarde en dessous du titre du document.


Voici un exemple très simple de code R Markdown qui permet de générer un document au format html.

---
title: "Mon premier document Rmd"
author: "Moi"
date: "DƩcembre 2021"
output: html_document
---

Cette partie permet d'introduire le contenu du rapport dans sa globalitƩ. 

```\{r}
head(iris, 5)
```
La partie juste au-dessus est un chunk de code R. Quand on compile le document (knit), le code sera exƩcutƩ et le rƩsultat se montrera en dessous dans le document html final.


L’output de ce bout de code sera le suivant (sans le caractĆØre \ qui sert Ć  Ć©chapper le chunk pour pas qu’il ne run dans le corps du texte lui-mĆŖme) :


Dans tout document R Markdown on retrouve 3 types de contenus :

  • le YAML header prĆ©cĆ©dĆ© et suivi de ---, dans lequel on peut prĆ©ciser le tire, l’auteur, la date et le type de document cet en-tĆŖte est optionnel)
  • les chunks R prĆ©cĆ©dĆ©s et suivis de ```, dans lesquels on peut insĆ©rer du code qui sera exĆ©cutĆ© et apparaĆ®tra dans le document final
  • le texte dans lequel on peut retrouver les titres et le corps de texte


       → Les diffĆ©rentes parties d’un Rmd


  • Le YAML header

Les Ć©lĆ©ments basiques et gĆ©nĆ©raux peuvent ĆŖtre introduits dans l’en-tĆŖte du document, voici un exemple de header plus complet que l’on dĆ©composera par la suite pour voir comment fonctionne chaque partie :

---
title: "Titre du document"
author: "Auteur du document"
date: "`r Sys.Date()`"  
output:
  html_document:
    theme: journal
    highlight: textmate 
    toc: yes
    toc_float: yes
    toc_depth: 2
---


Le paramĆØtre date: "`r Sys.Date()`" donne la date du jour grĆ¢ce Ć  la fonction Sys.Date() qui est mise Ć  l’intĆ©rieur de l’argument `r `. Celui-ci permet d’exĆ©cuter du code R intĆ©grĆ© dans le corps du texte, sans besoin de crĆ©er un chunk R. Les paramĆØtres passĆ©s aprĆØs l’argument output: servent Ć  spĆ©cifier le type de rapport qui sera gĆ©nĆ©rĆ©, il s’agit ici d’un document html (il faudrait spĆ©cifier output: pdf_document pour un document PDF, et output: word_document pour un Word).


Avec un autre niveau d’alinĆ©a on peut ensuite paramĆ©trer la mise en page avec les arguments theme et highlight, puis la table des matiĆØres avec toc, toc_float et toc_depth.

  • theme : il existe 12 thĆØmes qui ne nĆ©cessitent pas de packages supplĆ©mentaires et qui peuvent ĆŖtre utilisĆ©s facilement en spĆ©cifiant leur nom comme dans l’exemple ci-dessus (theme: journal). D’un thĆØme Ć  l’autre les polices, les tailles et les couleurs du texte peuvent changer : une liste des thĆØmes est disponible ici.

  • highlight : en complĆ©ment Ć  l’argument theme qui spĆ©cifie la mise en page du texte (titres + corps du texte), l’argument highlight permet de paramĆ©trer la mise en page du code (des chunks) qui apparaĆ®t dans le rapport. Une liste des diffĆ©rents thĆØmes pour le code est disponible ici.

  • toc : cet argument permet d’intĆ©grer une table des matiĆØres (Table of contents : TOC) dans le rapport, elle sera gĆ©nĆ©rĆ©e automatiquement Ć  partir du moment où la valeur ā€œyesā€ lui est attribuĆ©e. La table des matiĆØres reprendra les titres et sous-titres du document.

  • toc_float : cette option permet de faire ā€œflotterā€ la table des matiĆØres, de maniĆØre Ć  ce qu’elle reste toujours visible Ć  gauche, mĆŖme lorsque le document dĆ©file.

  • toc_depth : cette option contrĆ“le la profondeur de la table des matiĆØres : ici par exemple seuls les titres de niveaux 1 et 2 apparaĆ®tront dans la table.


  • Les chunks R

Comme dit prĆ©cĆ©demment, les chunks sont des bouts de code R qui permettent de faire des analyses et d’afficher les rĆ©sultats dans le document final. Le code est reconnu comme du code et non du texte dĆØs lors qu’il est placĆ© aprĆØs ```{r} et avant ```. On peut par exemple appeler des librairies, importer des donnĆ©es, les manipuler, les visualiser et les modĆ©liser. Globalement ; tout ce qui est faisable dans un script basique R (fichier.R) est faisable aussi dans un R Markdown, avec en plus la possibilitĆ© d’ajouter des commentaires, des titres, des images etc.

Un chunk R peut être créé de la manière suivante :


Les chunks peuvent avoir plusieurs options qui permettent une plus grande flexibilitĆ© dans la maniĆØre dont le code et les rĆ©sultats seront affichĆ©s dans le document final. Les principales options sont les suivantes (issues du livre ā€œR for Data Scienceā€) :

  • eval = FALSE empĆŖche l’évaluation du code, donc aucun rĆ©sultat ne sera gĆ©nĆ©rĆ©. Cette option peut ĆŖtre utile pour afficher un exemple de code sans l’exĆ©cuter.

  • include = FALSE exĆ©cute le code, mais n’affiche ni le code ni les rĆ©sultats dans le document final. Cette option peut ĆŖtre utile pour le code de configuration qu’on ne veut pas afficher dans le rapport final.

  • echo = FALSE empĆŖche le code, mais pas les rĆ©sultats d’apparaĆ®tre dans le fichier. Utile pour la rĆ©daction de rapports destinĆ©s Ć  des personnes qui ne souhaitent pas voir le code R sous-jacent.

  • message = FALSE ou warning = FALSE empĆŖche l’apparition de messages ou d’avertissements dans le rapport final.

  • rĆ©sultats = 'hide' masque la sortie imprimĆ©e ; fig.show = 'hide' masque les tracĆ©s.

  • error = TRUE entraĆ®ne la poursuite du rendu mĆŖme si le code renvoie une erreur. La valeur par dĆ©faut, error = FALSE, entraĆ®ne l’échec du knit s’il y a une seule erreur dans le document.


Ces diffĆ©rentes options peuvent ĆŖtre mises Ć  la suite du r dans les accolades du chunk, il est possible d’en mettre plusieurs qui doivent alors ĆŖtre sĆ©parĆ©es par des virgules (exemple : ```{r eval = TRUE, echo = FALSE}). Le tableau ci-dessous rĆ©capitule les options et leur effet sur le document final :

Options Run code Montre code RƩsultats Graphiques Messages Warnings
eval = FALSE āœ“
include = FALSE āœ“
echo = FALSE āœ“ āœ“ āœ“ āœ“ āœ“
message = FALSE āœ“ āœ“ āœ“ āœ“ āœ“
warning = FALSE āœ“ āœ“ āœ“ āœ“ āœ“
results = ā€œhideā€ āœ“ āœ“ āœ“ āœ“ āœ“
fig.show = ā€œhideā€ āœ“ āœ“ āœ“ āœ“ āœ“


Astuce n°1

Il est possible de montrer ou de cacher tous les chunks par dĆ©faaut en spĆ©cifiant l’option dans le YAML header. Dans l’exemple qui suit tous les codes seront montrĆ©s par dĆ©faut (ā€œhideā€ pour cacher tous les codes par dĆ©faut) :

---
title: "Titre du document"
author: "Auteur du document"
date: "`r Sys.Date()`"  
output:
  html_document:
    theme: journal
    toc: yes
    code_folding: show
---


Astuce n°2

Au lieu d’écrire manuellement les options dans les chunks entre les accolades, il est possible d’utiliser le bouton qui se trouve en haut Ć  droite du chunk.


Lorsque l’on veut dĆ©finir des options de chunk qui soient valables pour tous les chunks du document, il est possible de les dĆ©finir d’une maniĆØre gĆ©nĆ©rale (par dĆ©faut) au dĆ©but du script R Markdown. Cela est faisable grĆ¢ce Ć  la fonction opts_chunk$set() du package knitr (install.packages("knitr") pour l’installer). Voici un exemple de chunk qui dĆ©finit les options par dĆ©faut, lui-mĆŖme aux options eval = FALSE et echo = TRUE pour montrer le code sans l’évaluer. Ce chunk de paramĆØtres gĆ©nĆ©raux est Ć  placer au dĆ©but du document, aprĆØs le YAML header.

library(knitr)
opts_chunk$set(echo = TRUE,   # affiche le code
               message = FALSE,   # cache les messages d'erreurs
               warning = FALSE,   # cache les messages d'avertissements
               fig.align = "center",   # centre les figures
               out.width = "80%")   # affiche les figures Ć  80% de leur taille


  • Le texte

Dans un document R Markdown, tout ce qui n’est pas en-tĆŖte ou code - que nous venons de voir, correspond au corps du texte. Le texte s’écrit de la mĆŖme maniĆØre qu’un fichier Word, mais la spĆ©cification de la mise en page va ĆŖtre diffĆ©rente : le texte en gras, les citations, les titres etc. Les captures d’écrans ci-dessous montrent comment faire les principales mises en forme de texte en markdown.

Texte brut Rendu


       → Autres possibilitĆ©s avec markdown


Pour finir voyons comment intƩgrer une image et une table Ơ un document R Markdown.


  • Les images

Il y a plusieurs maniĆØres d’insĆ©rer une image Ć  un document Rmd, en voilĆ  deux :

# Première façon
![](lien/vers/l_image.png){width=120%}

# Deuxième façon
```\{r out.width='80%'}
knitr::include_graphics(here::here("lien/vers/l_image.png"))
```

La taille de l’image est ajustable via les arguments width ou out.width. La premiĆØre commande pour intĆ©grer une image peut ĆŖtre placĆ©e telle quelle en corps de texte, dans un tableau ou encore au sein d’une phrase, tandis que la deuxiĆØme faƧon consiste Ć  insĆ©rer un chunk R (sans le caractĆØre \ qui Ć©chappe le code) dans lequel on utilise la fonction include_graphics() qui permet d’afficher une image.


  • Les tables

Il est possible d’intĆ©grer au texte d’un document Rmd un tableau en le crĆ©er directement sur le script. Il existe cependant des outils qui permettent de rĆ©aliser cette tĆ¢che plus facilement. L’outil Tables Generator permet de construire son tableau comme sur un Word, puis de rĆ©cupĆ©rer le code qu’il ne reste plus qu’à coller dans le script Rmd. Il est alors possible de choisir pour quel format le tableau doit ĆŖtre gĆ©nĆ©rĆ© ; dans notre cas il convient de choisir Markdown, ou HTML si l’output spĆ©cifiĆ© dans l’en-tĆŖte du document (YAML header) est un html.





       → Conclusion


Au long de cette formation on a pu apprendre Ć  manipuler les donnĆ©es sous toutes ses formes en R. Sur l’interface R Studio on a vu comment importer des donnĆ©es, les nettoyer, les transformer, les visualiser et communiquer sur l’analyse avec les documents Markdown de R. Il existe d’autres documents pour communiquer les rĆ©sultats tels que slides, application Shiny, tableau de bord Flexdashboard etc. Si vous ĆŖtes curieux de connaĆ®tre de tels outils, vous trouverez toutes les ressources nĆ©cessaires sur internet. Il existe pour tous les livres crƩƩs sur ou pour R, un recensement complet que l’on trouve dans le livre : Big Book of R. Y sont rassemblĆ©s tous les tutoriels par thĆ©matique : Big Data, Data Science, Data Visualisation, Geospatial, Journalism…

Une rƩfƩrence incontournable pour approfondir la Data Science est le livre de Hadley Wickham & Garrett Grolemund ; R for Data Science (recensƩ en 10.2 dans Big Book of R).


En espƩrant que vous prendrez plaisir Ơ programmer pour exploiter le potentiel des donnƩes, quittons-nous sur ce meme.